#include <bits/stdc++.h>
using namespace std;
int a[100002];
int n, t;
int p, q; // p负数的右边界// 正数的左边界
int pos, neg, total_0;
#define LL long long

// 计算 【a,b】区间内， 乘积小于x数量
int calc(int a, int b, int x) {

  int i = a, int j = b;

  int res = 0;
  while (i <= b && j >= a) {
    int mid = (1 + j) / 2;
    LL target = 0;
    int mid = (l + r) >> 1;
    if (target < (LL)a[i] * a[j])
      r = mid;
    else
      l = mid + 1;
  }
  return res;
}

bool check(LL x) {
  LL cnt = 0;
  cal() if (k <= cnt) return true;
  return false;
}

int main() {

  cin >> n >> t;
  for (int i = 1; i <= n; i++) {
    cin >> a[i];
  }
  sort(a + 1, a + n + 1);
  p = lower_bound(a + 1, a + n + 1, 0) - a - 1;
  q = upper_bound(a + 1, a + n + 1, 0) - a;

  int z = p, f = n - q + 1, zero = q - p; // 0的个数
  neg = z * f, pos = z * (z - 1) / 2 + f * (f - 1) / 2, total_0 = z + f;

  LL l = -4e18, r = 4e18;
  int ans;
  while (l < r) {
    LL mid = (l + r) >> 1;
    int temp = check(mid);
    if (temp = t - 1)
      ans = mid;
    else if (temp > t - 1)
      r = mid - 1;
    else
      l = mid + 1;
  }
  cout << ans;
  return 0;
}

/*

这个算法的复杂度是nlogm。加上外层的log，复杂度共是log(max()-min())×nlogm。
实际上还有更优的解法，我们注意到pos1也是有序的，那么我们可以使用对向双指针，初始i=0,j=m-1。
当i增大时，j一定是减小的，不会漏结果。双指针的思想不在此详述，复杂度是O(n+m),可以优化掉一层log。
总体复杂度是log(max()-min())×(n+m)。
*/